package com.china.cnlongdb.basic.utils;

import java.io.File;
import java.lang.reflect.Field;
import java.text.NumberFormat;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Collections;
import java.util.Comparator;
import java.util.Date;
import java.util.List;

import org.apache.commons.lang3.StringUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import com.china.cnlongdb.basic.constant.LongDbConstant;
import com.china.cnlongdb.basic.entity.query.LongDbSort;
import com.china.cnlongdb.basic.enums.sort.LongDbSortMode;
import com.china.cnlongdb.basic.enums.sort.LongDbSortTypes;

/**
 * 数据查询后 - 排序工具类
 * 
 * 在数据库中查出来的列表中，往往需要对不同的字段重新排序。 一般的做法都是使用排序的字段，重新到数据库中查询。
 * 如果不到数据库查询，直接在第一次查出来的list中排序，无疑会提高系统的性能。 下面就写一个通用的方法，对list排序，
 * 
 * 至少需要满足以下5点：
 * 
 *  ①.list元素对象类型任意 ---->使用泛型解决
 * 
 *  ②.可以按照list元素对象的任意多个属性进行排序,即可以同时指定多个属性进行排序 --->使用java的可变参数解决
 * 
 *  ③.list元素对象属性的类型可以是数字(byte、short、int、long、float、double等，包括正数、负数、0)、字符串(char、String)、日期(java.util.Date)
 *    --->对于数字：统一转换为固定长度的字符串解决,比如数字3和123，转换为"003"和"123"
 *    ;再比如"-15"和"7"转换为"-015"和"007" --->对于日期：可以先把日期转化为long类型的数字，数字的解决方法如上
 * 
 *   ④.list元素对象的属性可以没有相应的getter和setter方法
 *     --->可以使用java反射进行获取private和protected修饰的属性值
 * 
 *   ⑤.list元素对象的对象的每个属性都可以指定是升序还是降序
 *     -->使用2个重写的方法(一个方法满足所有属性都按照升序(降序)，另外一个方法满足每个属性都能指定是升序(降序))
 */
public class ListSortUtils {
	
	private static final Logger logger = (Logger) LoggerFactory.getLogger(ListSortUtils.class);
	
	private static SimpleDateFormat sortFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
	
	/**
	 * 对list的元素按照多个属性名称排序 
	 * list元素的属性可以是数字（byte、short、int、long、float、double等，支持正数、负数、0）、char、String、java.util.Date
	 * @param lsit
	 * @param columnName list元素的属性名称
	 * @param isAsc true升序，false降序
	 */
	public static <E> List<E> sort(List<E> list, final boolean isAsc, final String... columnNameArr) {
		Collections.sort(list, new Comparator<E>() {
			public int compare(E a, E b) {
				int ret = 0;
				try {
					for (int i = 0; i < columnNameArr.length; i++) {
						ret = ListSortUtils.compareObject(columnNameArr[i], isAsc, a, b);
						if (0 != ret) {
							break;
						}
					}
				} catch (Exception e) {
					logger.error("执行排序异常："+e.getMessage(), e);
				}
				return ret;
			}
		});
		return list;
	}

	/**
	 * 给list的每个属性都指定是升序还是降序
	 * @param list
	 * @param columnNameArr 参数数组
	 * @param typeArr 每个属性对应的升降序数组， true升序，false降序
	 */
	public static <E> List<E> sort(List<E> list, final String[] columnNameArr, final boolean[] typeArr) {
		if (columnNameArr.length != typeArr.length) {
			throw new RuntimeException("属性数组元素个数和升降序数组元素个数不相等");
		}
		Collections.sort(list, new Comparator<E>() {
			public int compare(E a, E b) {
				int ret = 0;
				try {
					for (int i = 0; i < columnNameArr.length; i++) {
						ret = compareObject(columnNameArr[i], typeArr[i], a, b);
						if (0 != ret) {
							break;
						}
					}
				} catch (Exception e) {
					logger.error("执行排序异常："+e.getMessage(), e);
				}
				return ret;
			}
		});
		return list;
	}
	
	/**
	 * 功能描述：list排序，指定某个属性都是升序还是降序
	 * 模块作者：ZOUYONG
	 * 开发时间：2018年11月15日 下午9:35:31
	 * 更新记录：
	 * 返回数据：List<E>
	 */
	public static <E> List<E> sort(List<E> list, final LongDbSort sort) {
		Collections.sort(list, new Comparator<E>() {
			public int compare(E a, E b) {
				int ret = 0;
				try {
					boolean isAsc = sort.getOrder().equals(LongDbSortMode.ASC.name());
					ret = ListSortUtils.compareObject(sort.getField(), isAsc, a, b);
				} catch (Exception e) {
					logger.error("执行排序异常："+e.getMessage(), e);
				}
				return ret;
			}
		});
		return list;
	}
	
	/**
	 * 功能描述：list排序，指定多个属性是升序还是降序
	 * 模块作者：ZOUYONG
	 * 开发时间：2018年11月15日 下午9:32:37
	 * 更新记录：
	 * 返回数据：List<E>
	 */
	public static <E> List<E> sort(List<E> list, final List<LongDbSort> sortList) {
		Collections.sort(list, new Comparator<E>() {
			public int compare(E a, E b) {
				int ret = 0;
				try {
					for (int i = 0; i < sortList.size(); i++) {
						LongDbSort sort = sortList.get(i);
						boolean isAsc = sort.getOrder().equals(LongDbSortMode.ASC.name());
						ret = ListSortUtils.compareObject(sort.getField(), isAsc, a, b);
						if (0 != ret) {
							break;
						}
					}
				} catch (Exception e) {
					logger.error("执行排序异常："+e.getMessage(), e);
				}
				return ret;
			}
		});
		return list;
	}
	
	/**
	 * 功能描述：字符串排序，指定多个属性是升序还是降序
	 × 模块作者：ZOUYONG
	 × 开发时间：2018年11月30日 上午11:59:08
	 × 返回数据：List<String>
	 */
	public static List<String> sortStr(List<String> list, final List<LongDbSort> sortList) {
		Collections.sort(list, new Comparator<String>() {
			public int compare(String a, String b) {
				int ret = 0;
				try {
					for (int i = 0; i < sortList.size(); i++) {
						LongDbSort sort = sortList.get(i);
						ret = compareString(sort, a, b);
						if (0 != ret) {
							break;
						}
					}
				} catch (Exception e) {
					logger.error("执行排序异常："+e.getMessage(), e);
				}
				return ret;
			}
		});
		return list;
	}

	/**
	 * 功能描述：字符串某个属性进行排序
	 × 模块作者：ZOUYONG
	 × 开发时间：2018年11月30日 下午12:01:52
	 × 返回数据：int
	 * @throws Exception 
	 */
	protected static int compareString(LongDbSort sort, String one, String two) throws Exception {
		int ret;
		boolean isAsc = sort.getOrder().equals(LongDbSortMode.ASC.name());
		Object value1 = forceGetFieldString(one, sort.getField());
		Object value2 = forceGetFieldString(two, sort.getField());
		
		if(StringUtils.isBlank(value1.toString()) && StringUtils.isNotBlank(value2.toString())) {
			value1 = setObjectValue(sort.getType(), value1, isAsc);
		}
		if(StringUtils.isBlank(value2.toString()) && StringUtils.isNotBlank(value1.toString())) {
			value2 = setObjectValue(sort.getType(), value2, isAsc);
		}
		
		String str1 = value1.toString();
		String str2 = value2.toString();
		if (sort.getType().equals(LongDbSortTypes.Number.name())) {
			int maxlen = Math.max(str1.length(), str2.length());
			str1 = addZero2Str(Float.valueOf(str1), maxlen);
			str2 = addZero2Str(Float.valueOf(str2), maxlen);
		} else if (sort.getType().equals(LongDbSortTypes.Date.name())) {
			long time1 = new Date(Long.valueOf(str1)).getTime();
			long time2 = new Date(Long.valueOf(str2)).getTime();
			int maxlen = Long.toString(Math.max(time1, time2)).length();
			str1 = addZero2Str(time1, maxlen);
			str2 = addZero2Str(time2, maxlen);
		}
		
		if (isAsc) {
			ret = str1.compareTo(str2); // 升序
		} else {
			ret = str2.compareTo(str1); // 降序
		}
		return ret;
	}

	/**
	 * 功能描述：获取字符串中指定属性的值
	 × 模块作者：ZOUYONG
	 × 开发时间：2018年11月30日 下午12:14:13
	 × 返回数据：Object
	 */
	public static String forceGetFieldString(String content, String field) {
		if(StringUtils.isBlank(content)) {
			return content;
		}
		String key = field + LongDbConstant.longdbTableDataTranI;
		String newContent = content.substring(content.indexOf(key)+key.length());
		if(newContent.indexOf(LongDbConstant.longdbTableDataTranS) >= 0) {
			return newContent.substring(0, newContent.indexOf(LongDbConstant.longdbTableDataTranS));
		}
		return newContent;
	}

	/**
	 * 对2个对象按照指定属性名称进行排序
	 * 
	 * @param sortname 属性名称
	 * @param isAsc true升序，false降序
	 * @param a
	 * @param b
	 * @return 
	 * @throws Exception
	 */
	public static <E> int compareObject(final String sortname, final boolean isAsc, E a, E b) throws Exception {
		int ret = -1;
		Object value1 = ListSortUtils.forceGetFieldValue(a, sortname);
		Object value2 = ListSortUtils.forceGetFieldValue(b, sortname);
		String sortType = null;
		if (value1 instanceof Number) {
			sortType = LongDbSortTypes.Number.name();
		}
		else if (value1 instanceof Date) {
			sortType = LongDbSortTypes.Date.name();
		}
		else {
			sortType = LongDbSortTypes.String.name();
		}
		if(null == value1 && null != value2) {
			value1 = setObjectValue(sortType, value1, isAsc);
		}
		if(null == value2 && null != value1) {
			value2 = setObjectValue(sortType, value2, isAsc);
		}
		String str1 = value1.toString();
		String str2 = value2.toString();
		if (value1 instanceof Number && value2 instanceof Number) {
			int maxlen = Math.max(str1.length(), str2.length());
			str1 = ListSortUtils.addZero2Str((Number) value1, maxlen);
			str2 = ListSortUtils.addZero2Str((Number) value2, maxlen);
		} else if (value1 instanceof Date && value2 instanceof Date) {
			long time1 = ((Date) value1).getTime();
			long time2 = ((Date) value2).getTime();
			int maxlen = Long.toString(Math.max(time1, time2)).length();
			str1 = ListSortUtils.addZero2Str(time1, maxlen);
			str2 = ListSortUtils.addZero2Str(time2, maxlen);
		}
		
		if (isAsc) {
			ret = str1.compareTo(str2);
		} else {
			ret = str2.compareTo(str1);
		}
		return ret;
	}

	/**
	 * 功能描述：如果对象值为空，则设置在末尾
	 * 模块作者：ZOUYONG
	 * 开发时间：2018年11月15日 下午10:47:43
	 * 更新记录：
	 * 返回数据：Object
	 */
	public static Object setObjectValue(String sortType, Object value1, boolean isAsc) throws ParseException {
		if(sortType.equals(LongDbSortTypes.Number.name())) {
			if(isAsc) {
				value1 = Float.valueOf("9999999999999999999");
			} else {
				value1 = Float.valueOf("-9999999999999999999");
			}
		}
		else if(sortType.equals(LongDbSortTypes.Date.name())) {
			if(isAsc) {
				value1 = sortFormat.parse("5000-12-31 23:59:59");
			} else {
				value1 = sortFormat.parse("1000-12-31 23:59:59");
			}
		} else {
			if(isAsc) {
				value1 = "zzzzzzzzzzzzzzzzzzzzzzzzzzz";
			} else {
				value1 = "";
			}
		}
		return value1;
	}

	/**
	 * 给数字对象按照指定长度在左侧补0.
	 * 
	 * 使用案例: addZero2Str(11,4) 返回 "0011", addZero2Str(-18,6)返回 "-000018"
	 * 
	 * @param numObj 数字对象
	 * @param length 指定的长度
	 * @return
	 */
	public static String addZero2Str(Number numObj, int length) {
		NumberFormat nf = NumberFormat.getInstance();
		// 设置是否使用分组
		nf.setGroupingUsed(false);
		// 设置最大整数位数
		nf.setMaximumIntegerDigits(length);
		// 设置最小整数位数
		nf.setMinimumIntegerDigits(length);
		return nf.format(numObj);
	}

	/**
	 * 获取指定对象的指定属性值（去除private,protected的限制）
	 * 
	 * @param obj 属性名称所在的对象
	 * @param fieldName 属性名称
	 * @return
	 * @throws Exception
	 */
	public static Object forceGetFieldValue(Object obj, String fieldName) throws Exception {
		Field field = obj.getClass().getDeclaredField(fieldName);
		Object object = null;
		boolean accessible = field.isAccessible();
		if (!accessible) {
			// 如果是private,protected修饰的属性，需要修改为可以访问的
			field.setAccessible(true);
			object = field.get(obj);
			// 还原private,protected属性的访问性质
			field.setAccessible(accessible);
			return object;
		}
		object = field.get(obj);
		return object;
	}
	
	/**
	 * 功能描述：文件名称排序
	 * 模块作者：ZOUYONG
	 * 开发时间：2018年11月30日 下午9:25:27
	 * 更新记录：
	 * 返回数据：List<File>
	 */
	public static List<File> sortFileList(List<File> list, boolean isAsc) {
		Collections.sort(list, new Comparator<File>() {
		    @Override
		    public int compare(File o1, File o2) {
		        if (o1.isDirectory() && o2.isFile())
		            return -1;
		        if (o1.isFile() && o2.isDirectory())
		            return 1;
		        if(isAsc) {
		        	return o1.getName().compareTo(o2.getName());
		        }
		        return o2.getName().compareTo(o1.getName());
		    }
		});
		return list;
	}

}

